template<typename _T0_>
void Emergency(const char *format, const _T0_& t0)
{
if(mLogLevel > 6){
return;
}
a8::XValue args[] = {a8::XValue(t0)
       };
       SendLog("[EMERGENCY]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_>
void Emergency(const char *format, const _T0_& t0,
const _T1_& t1)
{
if(mLogLevel > 6){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1)
       };
       SendLog("[EMERGENCY]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_>
void Emergency(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2)
{
if(mLogLevel > 6){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2)
       };
       SendLog("[EMERGENCY]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_>
void Emergency(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3)
{
if(mLogLevel > 6){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3)
       };
       SendLog("[EMERGENCY]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_>
void Emergency(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4)
{
if(mLogLevel > 6){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4)
       };
       SendLog("[EMERGENCY]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_>
void Emergency(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5)
{
if(mLogLevel > 6){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5)
       };
       SendLog("[EMERGENCY]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_>
void Emergency(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6)
{
if(mLogLevel > 6){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6)
       };
       SendLog("[EMERGENCY]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_,
typename _T7_>
void Emergency(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6,
const _T7_& t7)
{
if(mLogLevel > 6){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6),
a8::XValue(t7)
       };
       SendLog("[EMERGENCY]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_,
typename _T7_,
typename _T8_>
void Emergency(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6,
const _T7_& t7,
const _T8_& t8)
{
if(mLogLevel > 6){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6),
a8::XValue(t7),
a8::XValue(t8)
       };
       SendLog("[EMERGENCY]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_>
void Alert(const char *format, const _T0_& t0)
{
if(mLogLevel > 5){
return;
}
a8::XValue args[] = {a8::XValue(t0)
       };
       SendLog("[ALERT]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_>
void Alert(const char *format, const _T0_& t0,
const _T1_& t1)
{
if(mLogLevel > 5){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1)
       };
       SendLog("[ALERT]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_>
void Alert(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2)
{
if(mLogLevel > 5){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2)
       };
       SendLog("[ALERT]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_>
void Alert(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3)
{
if(mLogLevel > 5){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3)
       };
       SendLog("[ALERT]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_>
void Alert(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4)
{
if(mLogLevel > 5){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4)
       };
       SendLog("[ALERT]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_>
void Alert(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5)
{
if(mLogLevel > 5){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5)
       };
       SendLog("[ALERT]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_>
void Alert(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6)
{
if(mLogLevel > 5){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6)
       };
       SendLog("[ALERT]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_,
typename _T7_>
void Alert(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6,
const _T7_& t7)
{
if(mLogLevel > 5){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6),
a8::XValue(t7)
       };
       SendLog("[ALERT]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_,
typename _T7_,
typename _T8_>
void Alert(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6,
const _T7_& t7,
const _T8_& t8)
{
if(mLogLevel > 5){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6),
a8::XValue(t7),
a8::XValue(t8)
       };
       SendLog("[ALERT]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_>
void Error(const char *format, const _T0_& t0)
{
if(mLogLevel > 4){
return;
}
a8::XValue args[] = {a8::XValue(t0)
       };
       SendLog("[ERROR]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_>
void Error(const char *format, const _T0_& t0,
const _T1_& t1)
{
if(mLogLevel > 4){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1)
       };
       SendLog("[ERROR]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_>
void Error(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2)
{
if(mLogLevel > 4){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2)
       };
       SendLog("[ERROR]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_>
void Error(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3)
{
if(mLogLevel > 4){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3)
       };
       SendLog("[ERROR]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_>
void Error(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4)
{
if(mLogLevel > 4){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4)
       };
       SendLog("[ERROR]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_>
void Error(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5)
{
if(mLogLevel > 4){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5)
       };
       SendLog("[ERROR]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_>
void Error(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6)
{
if(mLogLevel > 4){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6)
       };
       SendLog("[ERROR]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_,
typename _T7_>
void Error(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6,
const _T7_& t7)
{
if(mLogLevel > 4){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6),
a8::XValue(t7)
       };
       SendLog("[ERROR]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_,
typename _T7_,
typename _T8_>
void Error(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6,
const _T7_& t7,
const _T8_& t8)
{
if(mLogLevel > 4){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6),
a8::XValue(t7),
a8::XValue(t8)
       };
       SendLog("[ERROR]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_>
void Warning(const char *format, const _T0_& t0)
{
if(mLogLevel > 3){
return;
}
a8::XValue args[] = {a8::XValue(t0)
       };
       SendLog("[WARNING]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_>
void Warning(const char *format, const _T0_& t0,
const _T1_& t1)
{
if(mLogLevel > 3){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1)
       };
       SendLog("[WARNING]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_>
void Warning(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2)
{
if(mLogLevel > 3){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2)
       };
       SendLog("[WARNING]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_>
void Warning(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3)
{
if(mLogLevel > 3){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3)
       };
       SendLog("[WARNING]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_>
void Warning(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4)
{
if(mLogLevel > 3){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4)
       };
       SendLog("[WARNING]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_>
void Warning(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5)
{
if(mLogLevel > 3){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5)
       };
       SendLog("[WARNING]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_>
void Warning(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6)
{
if(mLogLevel > 3){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6)
       };
       SendLog("[WARNING]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_,
typename _T7_>
void Warning(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6,
const _T7_& t7)
{
if(mLogLevel > 3){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6),
a8::XValue(t7)
       };
       SendLog("[WARNING]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_,
typename _T7_,
typename _T8_>
void Warning(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6,
const _T7_& t7,
const _T8_& t8)
{
if(mLogLevel > 3){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6),
a8::XValue(t7),
a8::XValue(t8)
       };
       SendLog("[WARNING]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_>
void Notice(const char *format, const _T0_& t0)
{
if(mLogLevel > 2){
return;
}
a8::XValue args[] = {a8::XValue(t0)
       };
       SendLog("[NOTICE]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_>
void Notice(const char *format, const _T0_& t0,
const _T1_& t1)
{
if(mLogLevel > 2){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1)
       };
       SendLog("[NOTICE]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_>
void Notice(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2)
{
if(mLogLevel > 2){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2)
       };
       SendLog("[NOTICE]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_>
void Notice(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3)
{
if(mLogLevel > 2){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3)
       };
       SendLog("[NOTICE]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_>
void Notice(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4)
{
if(mLogLevel > 2){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4)
       };
       SendLog("[NOTICE]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_>
void Notice(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5)
{
if(mLogLevel > 2){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5)
       };
       SendLog("[NOTICE]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_>
void Notice(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6)
{
if(mLogLevel > 2){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6)
       };
       SendLog("[NOTICE]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_,
typename _T7_>
void Notice(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6,
const _T7_& t7)
{
if(mLogLevel > 2){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6),
a8::XValue(t7)
       };
       SendLog("[NOTICE]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_,
typename _T7_,
typename _T8_>
void Notice(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6,
const _T7_& t7,
const _T8_& t8)
{
if(mLogLevel > 2){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6),
a8::XValue(t7),
a8::XValue(t8)
       };
       SendLog("[NOTICE]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_>
void Info(const char *format, const _T0_& t0)
{
if(mLogLevel > 1){
return;
}
a8::XValue args[] = {a8::XValue(t0)
       };
       SendLog("[INFO]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_>
void Info(const char *format, const _T0_& t0,
const _T1_& t1)
{
if(mLogLevel > 1){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1)
       };
       SendLog("[INFO]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_>
void Info(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2)
{
if(mLogLevel > 1){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2)
       };
       SendLog("[INFO]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_>
void Info(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3)
{
if(mLogLevel > 1){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3)
       };
       SendLog("[INFO]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_>
void Info(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4)
{
if(mLogLevel > 1){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4)
       };
       SendLog("[INFO]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_>
void Info(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5)
{
if(mLogLevel > 1){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5)
       };
       SendLog("[INFO]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_>
void Info(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6)
{
if(mLogLevel > 1){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6)
       };
       SendLog("[INFO]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_,
typename _T7_>
void Info(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6,
const _T7_& t7)
{
if(mLogLevel > 1){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6),
a8::XValue(t7)
       };
       SendLog("[INFO]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_,
typename _T7_,
typename _T8_>
void Info(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6,
const _T7_& t7,
const _T8_& t8)
{
if(mLogLevel > 1){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6),
a8::XValue(t7),
a8::XValue(t8)
       };
       SendLog("[INFO]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_>
void Debug(const char *format, const _T0_& t0)
{
if(mLogLevel > 0){
return;
}
a8::XValue args[] = {a8::XValue(t0)
       };
       SendLog("[DEBUG]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_>
void Debug(const char *format, const _T0_& t0,
const _T1_& t1)
{
if(mLogLevel > 0){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1)
       };
       SendLog("[DEBUG]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_>
void Debug(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2)
{
if(mLogLevel > 0){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2)
       };
       SendLog("[DEBUG]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_>
void Debug(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3)
{
if(mLogLevel > 0){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3)
       };
       SendLog("[DEBUG]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_>
void Debug(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4)
{
if(mLogLevel > 0){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4)
       };
       SendLog("[DEBUG]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_>
void Debug(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5)
{
if(mLogLevel > 0){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5)
       };
       SendLog("[DEBUG]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_>
void Debug(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6)
{
if(mLogLevel > 0){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6)
       };
       SendLog("[DEBUG]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_,
typename _T7_>
void Debug(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6,
const _T7_& t7)
{
if(mLogLevel > 0){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6),
a8::XValue(t7)
       };
       SendLog("[DEBUG]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    template<typename _T0_,
typename _T1_,
typename _T2_,
typename _T3_,
typename _T4_,
typename _T5_,
typename _T6_,
typename _T7_,
typename _T8_>
void Debug(const char *format, const _T0_& t0,
const _T1_& t1,
const _T2_& t2,
const _T3_& t3,
const _T4_& t4,
const _T5_& t5,
const _T6_& t6,
const _T7_& t7,
const _T8_& t8)
{
if(mLogLevel > 0){
return;
}
a8::XValue args[] = {a8::XValue(t0),
a8::XValue(t1),
a8::XValue(t2),
a8::XValue(t3),
a8::XValue(t4),
a8::XValue(t5),
a8::XValue(t6),
a8::XValue(t7),
a8::XValue(t8)
       };
       SendLog("[DEBUG]", format, args, sizeof(args) / sizeof(a8::XValue));
    }
    
    